#include <stdlib.h>
#include <stdio.h>
#include <vector>
#include <cmath>

using namespace std;

typedef struct {
  int x;
  int y;
}ponto;

ponto maisEsquerda, maisDireita;


void le_pontos(int quantidade, vector<ponto> &partido){
    
    int x1,x2,y1,y2;
    ponto auxiliar;
    
    for ( int i = 0; i < quantidade; i++ ) {
      scanf("%d %d %d %d\n", &x1, &y1, &x2, &y2);
      auxiliar.x = x1;
      auxiliar.y = y1;
      if ( x1 < maisEsquerda.x )
        maisEsquerda = auxiliar;
      partido.push_back(auxiliar);
      auxiliar.x = x1;
      auxiliar.y = y2;
      partido.push_back(auxiliar);
      auxiliar.x = x2;
      auxiliar.y = y1;
      partido.push_back(auxiliar);
      auxiliar.x = x2;
      auxiliar.y = y2;
      if ( x2 > maisDireita.x )
        maisDireita = auxiliar;
      partido.push_back(auxiliar);
    }


}

//Função para responder de qual lado da reta traçada entre 'a' e 'b' esta o ponto 'c'
int posicaoRelativaReta(ponto a, ponto b, ponto c) {

  //Para sair da divisão por 0  
   if (a.x == b.x) {
    if (c.x > a.x)
      return 1;
    else if (c.x == a.x)
      return 0;
    else
      return -1;
  }


  //calculando o coeficiente angular da reta 'a' -> 'b'
  double A = (a.y-b.y);
  A = A/(a.x-b.x);


  //calculando o coeficiente linear
  double B = b.y - A*(b.x);

  //verifica a posição relativa de 'c' usando a equação os coeficientes da reta encontrados
  double Y = A * c.x + B;

  
  if ( Y-c.y > 0.00001 )
    return 1;
  else if ( Y-c.y > -0.00001 )
    return 0;
  else
    return -1;
 }


//Verifica a posição relativa dos pontos do Partido em relação a reta que passa por 'a' e 'b'
int encontraSide(ponto a, ponto b, vector<ponto> partido) {
 
  int PontosCoolineares = 0;
  int ladoAtual;
  //escolha arbitraria para diferenciar na primeira iteração
  int ladoPontoAnterior =  7;

  //Começa a procurar a orientação de cada ponto do Partido
  for ( int i=0; i < partido.size(); i++ ) {
    ladoAtual = posicaoRelativaReta(a,b,partido[i]); 
    if ( ladoAtual == 0 )
      PontosCoolineares++;
    if ( PontosCoolineares > 2 )
      return 0;
    if ( ladoAtual != ladoPontoAnterior) {
       
      //caso for a primeira passada  
      if ( ladoPontoAnterior == 7 && ladoAtual != 0)
        ladoPontoAnterior = ladoAtual;
      else if ( ladoAtual != 0 )
        return 0;
    }
  }
  return ladoPontoAnterior;
}


double distance(ponto a, ponto b, ponto p) {
  
  double result = 0;
  if (a.x == b.x)
    return p.x - a.x;
  double A = (b.y-a.y);
  A = A/(b.x-a.x);
  double B = a.y - A*(a.x);
  
  double Y = A*p.x+B;

  result = (A*p.x-p.y+B)/sqrt(A*A+1);
  result = abs(result);
  return result;
}

void find_hull(vector<ponto> *hull, vector<ponto> group, ponto left, ponto right) {
  if ( group.empty() )
    return;
  ponto far;
  double max_distance = 0;
  double temp_distance;
  for ( int i=0; i<group.size(); i++ ) {
    temp_distance = distance(left, right, group[i]);
    if ( temp_distance > max_distance ) {
      far = group[i];
      max_distance = temp_distance;
    }
  }
  hull->push_back(far);
  vector<ponto> S1;
  vector<ponto> S2;
  int side;
  for( int i=0; i<group.size(); i++ ) {
    side = posicaoRelativaReta(left, far, group[i]);
    if ( left.x > far.x )
      side = side-2*side;
    if ( side == 1 )
      S1.push_back(group[i]);
  }
  for( int i=0; i<group.size(); i++ ) {
    side = posicaoRelativaReta(far, right, group[i]);
    if ( far.x > right.x )
      side = -side;
    if ( side == 1 )
      S2.push_back(group[i]);
  }
  find_hull(hull, S1, left, far);
  find_hull(hull, S2, far, right);
}

int create_hull(vector<ponto> *hull, ponto left, ponto right, vector<ponto> group) {

  hull->push_back(left);
  hull->push_back(right);

  vector<ponto> S1;
  vector<ponto> S2;
  int side = 0;
  for( int i=0; i<group.size(); i++ ) {
    side = posicaoRelativaReta(left, right, group[i]);
    if ( side == 1 )
      S1.push_back(group[i]);
    else if ( side == -1 )
      S2.push_back(group[i]);
  }
  find_hull(hull, S1, left, right);
  find_hull(hull, S2, right, left);
}

int backTrack(int ndoors,int npenguins, vector<ponto> doors, vector<ponto> penguins){

    int side_doors = 0;
    int side_penguins = 0;
    int resposta =0;

    for ( int i=0; i<ndoors; i++ ) {
      for ( int j=0; j<npenguins; j++) {
        side_doors = encontraSide(doors[i],penguins[j],doors);
        side_penguins = encontraSide(doors[i],penguins[j],penguins);
        if ( side_doors != side_penguins && side_doors != 0 && side_penguins != 0) {
          resposta = 1;
          break;
        }
      }
      if (resposta == 1)
        break;
    }
    return resposta;
}



int main(int argc, char *argv[]){


  int ndoors;
  int npenguins;
  int N = 1;
  int resposta = 0;
  int x1,x2,y1,y2;
  
  while( scanf("%d %d\n",&ndoors,&npenguins)){
 
    //verifica se não há mais entradas
    if(ndoors == 0 && npenguins == 0)
      return 0;
    else if ( N > 1 ) printf("\n"); 

    //Vetores para armazenar os pontos de cada partido
    vector<ponto> doors;
    vector<ponto> penguins;
    vector<ponto> hull_doors;
    vector<ponto> hull_penguins;

    
    
    maisEsquerda.x = 15000;
    maisEsquerda.y = 15000;
    maisDireita.x = 0;
    maisDireita.y = 0;

    
    //le pontos doors
    le_pontos(ndoors,doors);

    create_hull(&hull_doors, maisEsquerda, maisDireita, doors);
    
    maisEsquerda.x = 15000;
    maisEsquerda.y = 15000;
    maisDireita.x = 0;
    maisDireita.y = 0;

    //le pontos penguins
    le_pontos(npenguins,penguins);
    
    create_hull(&hull_penguins, maisEsquerda, maisDireita, penguins);

    ndoors = hull_doors.size();
    npenguins = hull_penguins.size();


    //Inicia o backTracking, testando cada reta entre cada par de pontos doors,penguin
    resposta = backTrack(ndoors,npenguins,hull_doors,hull_penguins);
   
    if ( resposta== 0 )
      printf("Case %d: It is not possible to separate the two groups of vendors.\n", N);
    if ( resposta== 1 )
      printf("Case %d: It is possible to separate the two groups of vendors.\n", N);
    N++;
    doors.clear();
    penguins.clear();
    hull_doors.clear();
    hull_penguins.clear();
  }
}
